import { setHeader } from 'h3';
import { createReadStream } from 'fs';
import { verifyAccessToken } from '~/utils/jwt-utils';
import { unAuthorizedResponse, usePageResponseSuccess, useResponseSuccess, customResponse } from '~/utils/response';
import { queryDatabase, formatDateTime, creatDocxFile, getSecurePath, createZipBlob, formatBytes } from '~/functions';

const processField = (data: string | number, formateType: number) => {
  try {
    switch (formateType) {
      case 0:
        return data === '' ? '——' : data;
      case 1:
        // 去除开头的0071
        return data.toString().replace(/^0071/, '');
      case 2:
        // 保留三位有效数字
        const num = Number(data);
        if (isNaN(num)) return data.toString() + '%%';
        let unit: string = '';
        let res;
        if (num >= 0.09995) {
          res = num.toPrecision(3);
          unit = '%';
        } else if (num < 0.09995 && num > 0) {
          res = num * 10000;
          res = res.toPrecision(3);
          unit = 'ppm';
        } else if (num === 0) {
          res = '平衡气';
          unit = '';
        }

        return res + unit;
      // // 处理科学计数法
      // if (res.includes('e')) {
      //   let [numStr, exponent] = res.split('e');
      //   if (exponent.startsWith('+')) {
      //     exponent = exponent.slice(1); // 去掉正号
      //   }

      //   return `
      //       <w:p>
      //         <w:pPr>
      //             <w:snapToGrid w:val="0"/>
      //             <w:spacing w:line="200" w:lineRule="atLeast"/>
      //             <w:jc w:val="left"/>
      //             <w:rPr>
      //                 <w:rFonts w:hint="default" w:ascii="微软雅黑" w:hAnsi="微软雅黑" w:eastAsia="微软雅黑" w:cs="微软雅黑"/>
      //                 <w:sz w:val="15"/>
      //                 <w:szCs w:val="15"/>
      //                 <w:vertAlign w:val="superscript"/>
      //                 <w:lang w:val="en-US" w:eastAsia="zh-CN"/>
      //             </w:rPr>
      //         </w:pPr>
      //         <w:r>
      //             <w:rPr>
      //                 <w:rFonts w:hint="eastAsia" w:ascii="微软雅黑" w:hAnsi="微软雅黑" w:eastAsia="微软雅黑" w:cs="微软雅黑"/>
      //                 <w:sz w:val="15"/>
      //                 <w:szCs w:val="15"/>
      //                 <w:lang w:val="en-US" w:eastAsia="zh-CN"/>
      //             </w:rPr>
      //             <w:t>${numStr}</w:t>
      //         </w:r>
      //         <w:r>
      //             <w:rPr>
      //                 <w:rFonts w:hint="eastAsia" w:ascii="微软雅黑" w:hAnsi="微软雅黑" w:eastAsia="微软雅黑" w:cs="微软雅黑"/>
      //                 <w:sz w:val="15"/>
      //                 <w:szCs w:val="15"/>
      //                 <w:vertAlign w:val="superscript"/>
      //                 <w:lang w:val="en-US" w:eastAsia="zh-CN"/>
      //             </w:rPr>
      //             <w:t>${exponent}</w:t>
      //         </w:r>
      //         <w:r>
      //             <w:rPr>
      //                 <w:rFonts w:hint="eastAsia" w:ascii="微软雅黑" w:hAnsi="微软雅黑" w:eastAsia="微软雅黑" w:cs="微软雅黑"/>
      //                 <w:sz w:val="15"/>
      //                 <w:szCs w:val="15"/>
      //                 <w:lang w:val="en-US" w:eastAsia="zh-CN"/>
      //             </w:rPr>
      //             <w:t>${unit}</w:t>
      //         </w:r>
      //       </w:p>
      //     `;
      // } else {
      //   return `
      //       <w:p>
      //         <w:pPr>
      //           <w:snapToGrid w:val="0"/>
      //           <w:spacing w:line="200" w:lineRule="atLeast"/>
      //           <w:jc w:val="left"/>
      //           <w:rPr>
      //               <w:rFonts w:hint="default" w:ascii="微软雅黑" w:hAnsi="微软雅黑" w:eastAsia="微软雅黑" w:cs="微软雅黑"/>
      //               <w:sz w:val="15"/>
      //               <w:szCs w:val="15"/>
      //               <w:lang w:val="en-US" w:eastAsia="zh-CN"/>
      //           </w:rPr>
      //         </w:pPr>
      //         <w:r>
      //             <w:rPr>
      //                 <w:rFonts w:hint="eastAsia" w:ascii="微软雅黑" w:hAnsi="微软雅黑" w:eastAsia="微软雅黑" w:cs="微软雅黑"/>
      //                 <w:sz w:val="15"/>
      //                 <w:szCs w:val="15"/>
      //                 <w:lang w:val="en-US" w:eastAsia="zh-CN"/>
      //             </w:rPr>
      //             <w:t>${res}</w:t>
      //         </w:r>
      //       </w:p>
      //     `;
      // }
    }
  } catch {
    throw new Error(`无法格式化 ${data}`);
  }
};

// 处理表格
const processTable = (field: string) => {
  try {
    const rawData = JSON.parse(field);
    const res = Array.isArray(rawData) ? rawData : [rawData];
    return res.map((item) => {
      // 处理数据
      return {
        ...item,
        CustomerConcentration: processField(item.CustomerConcentration, 2),
        Concentration: processField(item.Concentration, 2),
        AnalyseConcentration: processField(item.AnalyseConcentration, 2),
        AnalyseMethod: processField(item.AnalyseMethod, 0),
      };
    });
  } catch {
    throw new Error(`表格数据格式化失败`);
  }
};

// 生成文件
async function generateFile(data: any) {
  let results = [];
  try {
    for (let i = 0; i < data.length; i++) {
      const queryString = `SELECT * FROM reportdata WHERE ID = ?`;
      const res = <any[]>await queryDatabase(queryString, [data[i]]);
      if (res.length <= 0) {
        throw new Error('未查询到匹配的数据');
      } else {
        const processData = res.map((item) => {
          return {
            ...item,
            SerialCode: processField(item.SerialCode, 1),
            AnalyseDate: formatDateTime(item.AnalyseDate, 'YYYY/MM/DD'),
            tableData: processTable(item.tableData),
          };
        });
        const filesRes = await creatDocxFile({
          docxTempName: 'report.docx',
          data: processData[0],
          outputName: processData[0].BottleCode,
          convert: false,
          replace: {
            origin: /(<w:p><\/w:p><\/w:tc><w:tc><w:tcPr>)/g,
            target: '</w:tc><w:tc><w:tcPr>',
          },
        });
        results.push(filesRes.docx);
      }
    }
    // console.log('生成文件:', results);
    return results;
  } catch (error) {
    throw new Error(`生成文件失败(${error.message})`);
  }
}

export default eventHandler(async (event) => {
  const userinfo = verifyAccessToken(event);
  if (!userinfo) {
    return unAuthorizedResponse(event);
  }

  try {
    let queryString;
    const args = [];
    // 读取POST请求的请求体，获取查询参数
    const { Listtype, page, pageSize, data, sortBy, sortOrder } = await readBody(event);
    if (Listtype === '1') {
      // 返回数据的列
      const columns = [
        'ID',
        'ProductOrderCode',
        'CustomerName',
        'SerialCode',
        'BottleCode',
        // 'BottleVolume',
        'GBName',
        'GBCode',
        'TechParams',
        // 'TouChanDate',
        // 'TouChanPersonName',
        // 'CompletedDate',
        // 'FillPressure',
        // 'minPressure',
        // 'AnalyseDate',
        // 'AnalystName',
        // 'ExpirationDate',
        'QuotationCode',
        // 'Note',
      ];

      // 处理排序字段和排序顺序
      let finalSortBy = sortBy || 'matchRes';
      let finalSortOrder = sortOrder || 'ASC';
      queryString = `SELECT ${columns.join(', ')} FROM reportdata ORDER BY ? ?`;
      // 合并排序的参数
      args.push(finalSortBy, finalSortOrder);
      // 调用 queryDatabase 函数执行操作
      const results = <any[]>await queryDatabase(queryString, args);
      if (results.length <= 0) {
        return useResponseSuccess({ message: '未查询到匹配的数据' });
      } else {
        const processData = results.map((item) => {
          return { ...item };
        });
        return usePageResponseSuccess(page as string, pageSize as string, processData);
      }
    } else if (Listtype === '2') {
      const outputDir = './public/output';
      // 处理数据
      const res = await generateFile(data);
      let resFilePath;
      // console.log('生成文件结束');
      if (res.length <= 0) {
        throw new Error('未生成任何文件');
      } else if (res.length === 1) {
        resFilePath = res[0];
      } else if (res.length > 1) {
        // 执行压缩
        try {
          const { resPath } = await createZipBlob(res, outputDir, true);
          // console.log('✅ ZIP Blob 创建成功');
          // console.log('📦 Blob 大小:', formatBytes(blob.size));
          // console.log('📦 ZIP 文件路径:', resPath);
          resFilePath = resPath;
        } catch (error) {
          // console.error('❌ 压缩失败:', error.message);
          throw new Error('压缩失败：' + error.message);
        }
      }

      // 安全路径处理
      const filePath = getSecurePath(outputDir, resFilePath);

      // console.log('准备返回数据：' + filePath);
      // 设置响应头
      setHeader(event, 'Content-Type', 'application/octet-stream');
      setHeader(event, 'Content-Disposition', `attachment; filename="${encodeURIComponent(resFilePath)}"`);
      let responseBlob: Blob;
      try {
        responseBlob = createReadStream(filePath); // 返回文件流
        return responseBlob;
      } catch (error) {
        throw new Error(`生成文件流失败: ${filePath}\n${error.message}`);
      }
    }
  } catch (error) {
    return customResponse(-2, error.message);
  }
});
